package cn.edu.sdju.fengguoyu.proto;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.52.1)",
    comments = "Source: AhoEdgeObMessage.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class ObserverMessageBroadcastGrpc {

  private ObserverMessageBroadcastGrpc() {}

  public static final String SERVICE_NAME = "aho_edge.ObserverMessageBroadcast";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.NewServiceMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendNewServiceMessageMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "sendNewServiceMessage",
      requestType = cn.edu.sdju.fengguoyu.proto.NewServiceMessage.class,
      responseType = cn.edu.sdju.fengguoyu.proto.AckMessage.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.NewServiceMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendNewServiceMessageMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.NewServiceMessage, cn.edu.sdju.fengguoyu.proto.AckMessage> getSendNewServiceMessageMethod;
    if ((getSendNewServiceMessageMethod = ObserverMessageBroadcastGrpc.getSendNewServiceMessageMethod) == null) {
      synchronized (ObserverMessageBroadcastGrpc.class) {
        if ((getSendNewServiceMessageMethod = ObserverMessageBroadcastGrpc.getSendNewServiceMessageMethod) == null) {
          ObserverMessageBroadcastGrpc.getSendNewServiceMessageMethod = getSendNewServiceMessageMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.NewServiceMessage, cn.edu.sdju.fengguoyu.proto.AckMessage>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "sendNewServiceMessage"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.NewServiceMessage.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.AckMessage.getDefaultInstance()))
              .setSchemaDescriptor(new ObserverMessageBroadcastMethodDescriptorSupplier("sendNewServiceMessage"))
              .build();
        }
      }
    }
    return getSendNewServiceMessageMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.NewUserMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendNewUserMessageMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "sendNewUserMessage",
      requestType = cn.edu.sdju.fengguoyu.proto.NewUserMessage.class,
      responseType = cn.edu.sdju.fengguoyu.proto.AckMessage.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.NewUserMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendNewUserMessageMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.NewUserMessage, cn.edu.sdju.fengguoyu.proto.AckMessage> getSendNewUserMessageMethod;
    if ((getSendNewUserMessageMethod = ObserverMessageBroadcastGrpc.getSendNewUserMessageMethod) == null) {
      synchronized (ObserverMessageBroadcastGrpc.class) {
        if ((getSendNewUserMessageMethod = ObserverMessageBroadcastGrpc.getSendNewUserMessageMethod) == null) {
          ObserverMessageBroadcastGrpc.getSendNewUserMessageMethod = getSendNewUserMessageMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.NewUserMessage, cn.edu.sdju.fengguoyu.proto.AckMessage>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "sendNewUserMessage"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.NewUserMessage.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.AckMessage.getDefaultInstance()))
              .setSchemaDescriptor(new ObserverMessageBroadcastMethodDescriptorSupplier("sendNewUserMessage"))
              .build();
        }
      }
    }
    return getSendNewUserMessageMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserLeaveMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendUserLeaveMessageMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "sendUserLeaveMessage",
      requestType = cn.edu.sdju.fengguoyu.proto.UserLeaveMessage.class,
      responseType = cn.edu.sdju.fengguoyu.proto.AckMessage.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserLeaveMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendUserLeaveMessageMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserLeaveMessage, cn.edu.sdju.fengguoyu.proto.AckMessage> getSendUserLeaveMessageMethod;
    if ((getSendUserLeaveMessageMethod = ObserverMessageBroadcastGrpc.getSendUserLeaveMessageMethod) == null) {
      synchronized (ObserverMessageBroadcastGrpc.class) {
        if ((getSendUserLeaveMessageMethod = ObserverMessageBroadcastGrpc.getSendUserLeaveMessageMethod) == null) {
          ObserverMessageBroadcastGrpc.getSendUserLeaveMessageMethod = getSendUserLeaveMessageMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.UserLeaveMessage, cn.edu.sdju.fengguoyu.proto.AckMessage>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "sendUserLeaveMessage"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.UserLeaveMessage.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.AckMessage.getDefaultInstance()))
              .setSchemaDescriptor(new ObserverMessageBroadcastMethodDescriptorSupplier("sendUserLeaveMessage"))
              .build();
        }
      }
    }
    return getSendUserLeaveMessageMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendServiceTimeoutMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "sendServiceTimeout",
      requestType = cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage.class,
      responseType = cn.edu.sdju.fengguoyu.proto.AckMessage.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendServiceTimeoutMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage, cn.edu.sdju.fengguoyu.proto.AckMessage> getSendServiceTimeoutMethod;
    if ((getSendServiceTimeoutMethod = ObserverMessageBroadcastGrpc.getSendServiceTimeoutMethod) == null) {
      synchronized (ObserverMessageBroadcastGrpc.class) {
        if ((getSendServiceTimeoutMethod = ObserverMessageBroadcastGrpc.getSendServiceTimeoutMethod) == null) {
          ObserverMessageBroadcastGrpc.getSendServiceTimeoutMethod = getSendServiceTimeoutMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage, cn.edu.sdju.fengguoyu.proto.AckMessage>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "sendServiceTimeout"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.AckMessage.getDefaultInstance()))
              .setSchemaDescriptor(new ObserverMessageBroadcastMethodDescriptorSupplier("sendServiceTimeout"))
              .build();
        }
      }
    }
    return getSendServiceTimeoutMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendServiceErrorMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "sendServiceError",
      requestType = cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage.class,
      responseType = cn.edu.sdju.fengguoyu.proto.AckMessage.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendServiceErrorMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage, cn.edu.sdju.fengguoyu.proto.AckMessage> getSendServiceErrorMethod;
    if ((getSendServiceErrorMethod = ObserverMessageBroadcastGrpc.getSendServiceErrorMethod) == null) {
      synchronized (ObserverMessageBroadcastGrpc.class) {
        if ((getSendServiceErrorMethod = ObserverMessageBroadcastGrpc.getSendServiceErrorMethod) == null) {
          ObserverMessageBroadcastGrpc.getSendServiceErrorMethod = getSendServiceErrorMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage, cn.edu.sdju.fengguoyu.proto.AckMessage>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "sendServiceError"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.AckMessage.getDefaultInstance()))
              .setSchemaDescriptor(new ObserverMessageBroadcastMethodDescriptorSupplier("sendServiceError"))
              .build();
        }
      }
    }
    return getSendServiceErrorMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.NewConnectionMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendNewConnectionMessageMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "sendNewConnectionMessage",
      requestType = cn.edu.sdju.fengguoyu.proto.NewConnectionMessage.class,
      responseType = cn.edu.sdju.fengguoyu.proto.AckMessage.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.NewConnectionMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendNewConnectionMessageMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.NewConnectionMessage, cn.edu.sdju.fengguoyu.proto.AckMessage> getSendNewConnectionMessageMethod;
    if ((getSendNewConnectionMessageMethod = ObserverMessageBroadcastGrpc.getSendNewConnectionMessageMethod) == null) {
      synchronized (ObserverMessageBroadcastGrpc.class) {
        if ((getSendNewConnectionMessageMethod = ObserverMessageBroadcastGrpc.getSendNewConnectionMessageMethod) == null) {
          ObserverMessageBroadcastGrpc.getSendNewConnectionMessageMethod = getSendNewConnectionMessageMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.NewConnectionMessage, cn.edu.sdju.fengguoyu.proto.AckMessage>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "sendNewConnectionMessage"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.NewConnectionMessage.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.AckMessage.getDefaultInstance()))
              .setSchemaDescriptor(new ObserverMessageBroadcastMethodDescriptorSupplier("sendNewConnectionMessage"))
              .build();
        }
      }
    }
    return getSendNewConnectionMessageMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceRankMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendServiceRankMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "sendServiceRank",
      requestType = cn.edu.sdju.fengguoyu.proto.ServiceRankMessage.class,
      responseType = cn.edu.sdju.fengguoyu.proto.AckMessage.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceRankMessage,
      cn.edu.sdju.fengguoyu.proto.AckMessage> getSendServiceRankMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceRankMessage, cn.edu.sdju.fengguoyu.proto.AckMessage> getSendServiceRankMethod;
    if ((getSendServiceRankMethod = ObserverMessageBroadcastGrpc.getSendServiceRankMethod) == null) {
      synchronized (ObserverMessageBroadcastGrpc.class) {
        if ((getSendServiceRankMethod = ObserverMessageBroadcastGrpc.getSendServiceRankMethod) == null) {
          ObserverMessageBroadcastGrpc.getSendServiceRankMethod = getSendServiceRankMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.ServiceRankMessage, cn.edu.sdju.fengguoyu.proto.AckMessage>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "sendServiceRank"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.ServiceRankMessage.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.AckMessage.getDefaultInstance()))
              .setSchemaDescriptor(new ObserverMessageBroadcastMethodDescriptorSupplier("sendServiceRank"))
              .build();
        }
      }
    }
    return getSendServiceRankMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static ObserverMessageBroadcastStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<ObserverMessageBroadcastStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<ObserverMessageBroadcastStub>() {
        @java.lang.Override
        public ObserverMessageBroadcastStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new ObserverMessageBroadcastStub(channel, callOptions);
        }
      };
    return ObserverMessageBroadcastStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static ObserverMessageBroadcastBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<ObserverMessageBroadcastBlockingStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<ObserverMessageBroadcastBlockingStub>() {
        @java.lang.Override
        public ObserverMessageBroadcastBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new ObserverMessageBroadcastBlockingStub(channel, callOptions);
        }
      };
    return ObserverMessageBroadcastBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static ObserverMessageBroadcastFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<ObserverMessageBroadcastFutureStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<ObserverMessageBroadcastFutureStub>() {
        @java.lang.Override
        public ObserverMessageBroadcastFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new ObserverMessageBroadcastFutureStub(channel, callOptions);
        }
      };
    return ObserverMessageBroadcastFutureStub.newStub(factory, channel);
  }

  /**
   */
  public static abstract class ObserverMessageBroadcastImplBase implements io.grpc.BindableService {

    /**
     */
    public void sendNewServiceMessage(cn.edu.sdju.fengguoyu.proto.NewServiceMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSendNewServiceMessageMethod(), responseObserver);
    }

    /**
     */
    public void sendNewUserMessage(cn.edu.sdju.fengguoyu.proto.NewUserMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSendNewUserMessageMethod(), responseObserver);
    }

    /**
     */
    public void sendUserLeaveMessage(cn.edu.sdju.fengguoyu.proto.UserLeaveMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSendUserLeaveMessageMethod(), responseObserver);
    }

    /**
     */
    public void sendServiceTimeout(cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSendServiceTimeoutMethod(), responseObserver);
    }

    /**
     */
    public void sendServiceError(cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSendServiceErrorMethod(), responseObserver);
    }

    /**
     */
    public void sendNewConnectionMessage(cn.edu.sdju.fengguoyu.proto.NewConnectionMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSendNewConnectionMessageMethod(), responseObserver);
    }

    /**
     */
    public void sendServiceRank(cn.edu.sdju.fengguoyu.proto.ServiceRankMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSendServiceRankMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getSendNewServiceMessageMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.NewServiceMessage,
                cn.edu.sdju.fengguoyu.proto.AckMessage>(
                  this, METHODID_SEND_NEW_SERVICE_MESSAGE)))
          .addMethod(
            getSendNewUserMessageMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.NewUserMessage,
                cn.edu.sdju.fengguoyu.proto.AckMessage>(
                  this, METHODID_SEND_NEW_USER_MESSAGE)))
          .addMethod(
            getSendUserLeaveMessageMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.UserLeaveMessage,
                cn.edu.sdju.fengguoyu.proto.AckMessage>(
                  this, METHODID_SEND_USER_LEAVE_MESSAGE)))
          .addMethod(
            getSendServiceTimeoutMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage,
                cn.edu.sdju.fengguoyu.proto.AckMessage>(
                  this, METHODID_SEND_SERVICE_TIMEOUT)))
          .addMethod(
            getSendServiceErrorMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage,
                cn.edu.sdju.fengguoyu.proto.AckMessage>(
                  this, METHODID_SEND_SERVICE_ERROR)))
          .addMethod(
            getSendNewConnectionMessageMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.NewConnectionMessage,
                cn.edu.sdju.fengguoyu.proto.AckMessage>(
                  this, METHODID_SEND_NEW_CONNECTION_MESSAGE)))
          .addMethod(
            getSendServiceRankMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.ServiceRankMessage,
                cn.edu.sdju.fengguoyu.proto.AckMessage>(
                  this, METHODID_SEND_SERVICE_RANK)))
          .build();
    }
  }

  /**
   */
  public static final class ObserverMessageBroadcastStub extends io.grpc.stub.AbstractAsyncStub<ObserverMessageBroadcastStub> {
    private ObserverMessageBroadcastStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected ObserverMessageBroadcastStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new ObserverMessageBroadcastStub(channel, callOptions);
    }

    /**
     */
    public void sendNewServiceMessage(cn.edu.sdju.fengguoyu.proto.NewServiceMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSendNewServiceMessageMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void sendNewUserMessage(cn.edu.sdju.fengguoyu.proto.NewUserMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSendNewUserMessageMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void sendUserLeaveMessage(cn.edu.sdju.fengguoyu.proto.UserLeaveMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSendUserLeaveMessageMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void sendServiceTimeout(cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSendServiceTimeoutMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void sendServiceError(cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSendServiceErrorMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void sendNewConnectionMessage(cn.edu.sdju.fengguoyu.proto.NewConnectionMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSendNewConnectionMessageMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void sendServiceRank(cn.edu.sdju.fengguoyu.proto.ServiceRankMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSendServiceRankMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   */
  public static final class ObserverMessageBroadcastBlockingStub extends io.grpc.stub.AbstractBlockingStub<ObserverMessageBroadcastBlockingStub> {
    private ObserverMessageBroadcastBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected ObserverMessageBroadcastBlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new ObserverMessageBroadcastBlockingStub(channel, callOptions);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.AckMessage sendNewServiceMessage(cn.edu.sdju.fengguoyu.proto.NewServiceMessage request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSendNewServiceMessageMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.AckMessage sendNewUserMessage(cn.edu.sdju.fengguoyu.proto.NewUserMessage request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSendNewUserMessageMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.AckMessage sendUserLeaveMessage(cn.edu.sdju.fengguoyu.proto.UserLeaveMessage request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSendUserLeaveMessageMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.AckMessage sendServiceTimeout(cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSendServiceTimeoutMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.AckMessage sendServiceError(cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSendServiceErrorMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.AckMessage sendNewConnectionMessage(cn.edu.sdju.fengguoyu.proto.NewConnectionMessage request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSendNewConnectionMessageMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.AckMessage sendServiceRank(cn.edu.sdju.fengguoyu.proto.ServiceRankMessage request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSendServiceRankMethod(), getCallOptions(), request);
    }
  }

  /**
   */
  public static final class ObserverMessageBroadcastFutureStub extends io.grpc.stub.AbstractFutureStub<ObserverMessageBroadcastFutureStub> {
    private ObserverMessageBroadcastFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected ObserverMessageBroadcastFutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new ObserverMessageBroadcastFutureStub(channel, callOptions);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.AckMessage> sendNewServiceMessage(
        cn.edu.sdju.fengguoyu.proto.NewServiceMessage request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSendNewServiceMessageMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.AckMessage> sendNewUserMessage(
        cn.edu.sdju.fengguoyu.proto.NewUserMessage request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSendNewUserMessageMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.AckMessage> sendUserLeaveMessage(
        cn.edu.sdju.fengguoyu.proto.UserLeaveMessage request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSendUserLeaveMessageMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.AckMessage> sendServiceTimeout(
        cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSendServiceTimeoutMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.AckMessage> sendServiceError(
        cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSendServiceErrorMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.AckMessage> sendNewConnectionMessage(
        cn.edu.sdju.fengguoyu.proto.NewConnectionMessage request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSendNewConnectionMessageMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.AckMessage> sendServiceRank(
        cn.edu.sdju.fengguoyu.proto.ServiceRankMessage request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSendServiceRankMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_SEND_NEW_SERVICE_MESSAGE = 0;
  private static final int METHODID_SEND_NEW_USER_MESSAGE = 1;
  private static final int METHODID_SEND_USER_LEAVE_MESSAGE = 2;
  private static final int METHODID_SEND_SERVICE_TIMEOUT = 3;
  private static final int METHODID_SEND_SERVICE_ERROR = 4;
  private static final int METHODID_SEND_NEW_CONNECTION_MESSAGE = 5;
  private static final int METHODID_SEND_SERVICE_RANK = 6;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final ObserverMessageBroadcastImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(ObserverMessageBroadcastImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_SEND_NEW_SERVICE_MESSAGE:
          serviceImpl.sendNewServiceMessage((cn.edu.sdju.fengguoyu.proto.NewServiceMessage) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage>) responseObserver);
          break;
        case METHODID_SEND_NEW_USER_MESSAGE:
          serviceImpl.sendNewUserMessage((cn.edu.sdju.fengguoyu.proto.NewUserMessage) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage>) responseObserver);
          break;
        case METHODID_SEND_USER_LEAVE_MESSAGE:
          serviceImpl.sendUserLeaveMessage((cn.edu.sdju.fengguoyu.proto.UserLeaveMessage) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage>) responseObserver);
          break;
        case METHODID_SEND_SERVICE_TIMEOUT:
          serviceImpl.sendServiceTimeout((cn.edu.sdju.fengguoyu.proto.ServiceTimeoutMessage) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage>) responseObserver);
          break;
        case METHODID_SEND_SERVICE_ERROR:
          serviceImpl.sendServiceError((cn.edu.sdju.fengguoyu.proto.ServiceErrorMessage) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage>) responseObserver);
          break;
        case METHODID_SEND_NEW_CONNECTION_MESSAGE:
          serviceImpl.sendNewConnectionMessage((cn.edu.sdju.fengguoyu.proto.NewConnectionMessage) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage>) responseObserver);
          break;
        case METHODID_SEND_SERVICE_RANK:
          serviceImpl.sendServiceRank((cn.edu.sdju.fengguoyu.proto.ServiceRankMessage) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.AckMessage>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class ObserverMessageBroadcastBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    ObserverMessageBroadcastBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return cn.edu.sdju.fengguoyu.proto.AhoEdgeObMessage.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("ObserverMessageBroadcast");
    }
  }

  private static final class ObserverMessageBroadcastFileDescriptorSupplier
      extends ObserverMessageBroadcastBaseDescriptorSupplier {
    ObserverMessageBroadcastFileDescriptorSupplier() {}
  }

  private static final class ObserverMessageBroadcastMethodDescriptorSupplier
      extends ObserverMessageBroadcastBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    ObserverMessageBroadcastMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (ObserverMessageBroadcastGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new ObserverMessageBroadcastFileDescriptorSupplier())
              .addMethod(getSendNewServiceMessageMethod())
              .addMethod(getSendNewUserMessageMethod())
              .addMethod(getSendUserLeaveMessageMethod())
              .addMethod(getSendServiceTimeoutMethod())
              .addMethod(getSendServiceErrorMethod())
              .addMethod(getSendNewConnectionMessageMethod())
              .addMethod(getSendServiceRankMethod())
              .build();
        }
      }
    }
    return result;
  }
}
